{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "[1]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 7.98e-08\n",
      "b1 relative error: 1.35e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.829613\n",
      "(Iteration 201 / 4900) loss: 1.857390\n",
      "(Iteration 301 / 4900) loss: 1.744448\n",
      "(Iteration 401 / 4900) loss: 1.420187\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.565913\n",
      "(Iteration 601 / 4900) loss: 1.700510\n",
      "(Iteration 701 / 4900) loss: 1.732213\n",
      "(Iteration 801 / 4900) loss: 1.688361\n",
      "(Iteration 901 / 4900) loss: 1.439529\n",
      "(Epoch 2 / 10) train acc: 0.497000; val_acc: 0.468000\n",
      "(Iteration 1001 / 4900) loss: 1.385772\n",
      "(Iteration 1101 / 4900) loss: 1.278401\n",
      "(Iteration 1201 / 4900) loss: 1.641580\n",
      "(Iteration 1301 / 4900) loss: 1.438847\n",
      "(Iteration 1401 / 4900) loss: 1.172536\n",
      "(Epoch 3 / 10) train acc: 0.490000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.346286\n",
      "(Iteration 1601 / 4900) loss: 1.268492\n",
      "(Iteration 1701 / 4900) loss: 1.318215\n",
      "(Iteration 1801 / 4900) loss: 1.395750\n",
      "(Iteration 1901 / 4900) loss: 1.338233\n",
      "(Epoch 4 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 2001 / 4900) loss: 1.343165\n",
      "(Iteration 2101 / 4900) loss: 1.393173\n",
      "(Iteration 2201 / 4900) loss: 1.276734\n",
      "(Iteration 2301 / 4900) loss: 1.287951\n",
      "(Iteration 2401 / 4900) loss: 1.352778\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.475000\n",
      "(Iteration 2501 / 4900) loss: 1.390234\n",
      "(Iteration 2601 / 4900) loss: 1.276361\n",
      "(Iteration 2701 / 4900) loss: 1.111768\n",
      "(Iteration 2801 / 4900) loss: 1.271688\n",
      "(Iteration 2901 / 4900) loss: 1.272039\n",
      "(Epoch 6 / 10) train acc: 0.546000; val_acc: 0.509000\n",
      "(Iteration 3001 / 4900) loss: 1.304489\n",
      "(Iteration 3101 / 4900) loss: 1.346667\n",
      "(Iteration 3201 / 4900) loss: 1.325510\n",
      "(Iteration 3301 / 4900) loss: 1.392728\n",
      "(Iteration 3401 / 4900) loss: 1.402001\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 3501 / 4900) loss: 1.319024\n",
      "(Iteration 3601 / 4900) loss: 1.153287\n",
      "(Iteration 3701 / 4900) loss: 1.180922\n",
      "(Iteration 3801 / 4900) loss: 1.093164\n",
      "(Iteration 3901 / 4900) loss: 1.135902\n",
      "(Epoch 8 / 10) train acc: 0.568000; val_acc: 0.490000\n",
      "(Iteration 4001 / 4900) loss: 1.191735\n",
      "(Iteration 4101 / 4900) loss: 1.359396\n",
      "(Iteration 4201 / 4900) loss: 1.227283\n",
      "(Iteration 4301 / 4900) loss: 1.024113\n",
      "(Iteration 4401 / 4900) loss: 1.327583\n",
      "(Epoch 9 / 10) train acc: 0.592000; val_acc: 0.504000\n",
      "(Iteration 4501 / 4900) loss: 0.963330\n",
      "(Iteration 4601 / 4900) loss: 1.445619\n",
      "(Iteration 4701 / 4900) loss: 1.007542\n",
      "(Iteration 4801 / 4900) loss: 1.005175\n",
      "(Epoch 10 / 10) train acc: 0.611000; val_acc: 0.512000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                lr_decay=0.95,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 3.90e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 2.13e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.57e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 357.428290\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.111000\n",
      "(Epoch 1 / 20) train acc: 0.380000; val_acc: 0.141000\n",
      "(Epoch 2 / 20) train acc: 0.520000; val_acc: 0.138000\n",
      "(Epoch 3 / 20) train acc: 0.740000; val_acc: 0.130000\n",
      "(Epoch 4 / 20) train acc: 0.820000; val_acc: 0.153000\n",
      "(Epoch 5 / 20) train acc: 0.860000; val_acc: 0.175000\n",
      "(Iteration 11 / 40) loss: 6.726589\n",
      "(Epoch 6 / 20) train acc: 0.940000; val_acc: 0.163000\n",
      "(Epoch 7 / 20) train acc: 0.960000; val_acc: 0.166000\n",
      "(Epoch 8 / 20) train acc: 0.960000; val_acc: 0.164000\n",
      "(Epoch 9 / 20) train acc: 0.980000; val_acc: 0.162000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.162000\n",
      "(Iteration 21 / 40) loss: 0.800243\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Iteration 31 / 40) loss: 0.000000\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.158000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "learning_rate = 1e-3  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 166.501707\n",
      "(Epoch 0 / 20) train acc: 0.240000; val_acc: 0.116000\n",
      "(Epoch 1 / 20) train acc: 0.240000; val_acc: 0.085000\n",
      "(Epoch 2 / 20) train acc: 0.340000; val_acc: 0.110000\n",
      "(Epoch 3 / 20) train acc: 0.460000; val_acc: 0.139000\n",
      "(Epoch 4 / 20) train acc: 0.700000; val_acc: 0.134000\n",
      "(Epoch 5 / 20) train acc: 0.800000; val_acc: 0.120000\n",
      "(Iteration 11 / 40) loss: 7.619979\n",
      "(Epoch 6 / 20) train acc: 0.800000; val_acc: 0.140000\n",
      "(Epoch 7 / 20) train acc: 0.820000; val_acc: 0.128000\n",
      "(Epoch 8 / 20) train acc: 0.880000; val_acc: 0.140000\n",
      "(Epoch 9 / 20) train acc: 0.920000; val_acc: 0.121000\n",
      "(Epoch 10 / 20) train acc: 0.920000; val_acc: 0.127000\n",
      "(Iteration 21 / 40) loss: 1.669786\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.131000\n",
      "(Epoch 12 / 20) train acc: 0.980000; val_acc: 0.125000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.137000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Iteration 31 / 40) loss: 0.000445\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.132000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmQAAAHwCAYAAAAIDnN0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3dfbhlZ10f/O/PScCRt0EzIBnAoMVRkZrANNUHtRGVAXxhpLVAq6LSBntJq8VnNOHxhVp9yGMUtV5KjUql5U0uCRGtGCmoFB4lTEgkiTga3mRmYhKNA0TmwWT4PX+cNXgS55ycOTl73zuzP5/rOtfe+17r3ut31lnX5Jt132ut6u4AADDOp40uAABg2QlkAACDCWQAAIMJZAAAgwlkAACDCWQAAIMJZMBcVdW2qrq9qh69letuoo4fq6pf3ervXWNbX1NVH1xn+S9X1YvmUQuwmM4YXQCw2Krq9lUfPyPJJ5Icnz4/v7tfdSrf193Hkzxwq9e9L+vuf7OR9arqUJJv6e7fn21FwLwJZMC6uvtTgWg6y/Nvuvt/rbV+VZ3R3XfOozY2zt8FFpshS+BemYb+fq2qXlNVH0vyLVX1ZVX1R1V1tKpuqqr/UlVnTuufUVVdVedMn185LX9TVX2sqv6wqh5zqutOy59WVX9WVR+pqp+rqndU1bdv8PfYV1U3TDW/tap2r1r2oqo6UlUfrao/raoLpvYvrap3T+03V9Wl97CN76+qW6fv+rZV7a+sqhdP7x9WVb891XFbVb1tan9NkrOTvGkaxn3hBuo+VFX7q+q6JB+vqour6tfuVtPLquonN7KPgNkRyICt8E1JXp3kIUl+LcmdSb4nyVlJnpTkqUmev07/f5Xkh5J8ZpK/SPKfT3XdqnpYktcl2T9t9wNJzt9I8VX1hUlemeTfJ9mZ5H8l+c2qOrOqHjfV/oTufnCSp03bTZKfS3Lp1P6Pkvz6Opt5ZJLtWQlV35XkZVX14JOstz/J+6c6Pnv6XdPdz0lyJMnTuvuB3f3S9epe9X3Pnmp+SJL/keTrTmy3qu6X5JundmAggQzYCm/v7t/s7k9297Hufld3v7O77+zu9ye5LMk/W6f/r3f3ge6+I8mrkpy7iXW/Psm13f0b07KfTvJXG6z/2Une2N1vnfpekuTBSf5pVsLlpyd53DTs94Hpd0qSO5I8tqo+q7s/1t3vXGcb/1+SH+vuO7r7jVmZi/f5J1nvjqyEtkd399919x9ssu4Tfra7D01/l0NJ/jDJP5+WPT3Jke7+43W2AcyBQAZshQ+v/lBVX1BV/7Oq/rKqPprkR7Ny1motf7nq/cez/kT+tdY9e3Ud3d1JDm2g9hN9P7Sq7yenvru6+2CS78vK73DLNDT72dOq35Hki5IcrKqrqurp62zjr6aLFE5W+2qXTLW8pareV1X7N1P3qnU+fLc+r0jyLdP7b4mzY7AQBDJgK/TdPv9ikuuT/KNpOO+Hk9SMa7gpK8OCSZKqqtw1mKznSJLPWdX306bvOpwk3f3K7n5Sksck2ZbkJVP7we5+dpKHJfmpJK+vqk+/N79Ed3+0u/9jd5+TZF+SH6iqE2cX776f1617jT6XJ3niNBT7tKwMNQODCWTALDwoyUeS/O00z2m9+WNb5beSPKGqvqGqzsjKHLadG+z7uiTfWFUXTPOv9if5WJJ3VtUXVtVXVdX9kxybfo4nSVV9a1WdNZ2Z+khWws8n780vMdX/eVOg/Mi0rRNn1m5O8rkbqXut7+/ujyd5Q5LXJHlHdx9ea11gfgQyYBa+L8lzsxIOfjErE/1nqrtvTvKsJC9N8tdJPi/JNVmZq3VPfW/ISr0vS3JrVi5C+MZpXtb9k/xEVuaj/WWShyb5wanr05O8d7q69CeTPKu7/+5e/iq7k7w1ye1J3pGVOWBvn5b930n+03RF5ffeQ93reUWSx8dwJSyMWplmAXB6qaptWRnS+xfd/b9H17NIqupzk7wnyWd39+33tD4we86QAaeNqnpqVT1kGl78oaxcIXnV4LIWyjTP7IVJXi2MweJwp37gdPLlWbkVxv2S3JBkX3ff45Dlsqiqh2Rlwv8Hk+wdWw2wmiFLAIDBDFkCAAwmkAEADHafnkN21lln9TnnnDO6DACAe3T11Vf/VXef9P6I9+lAds455+TAgQOjywAAuEdV9aG1lhmyBAAYTCADABhMIAMAGEwgAwAYTCADABhMIAMAGEwgAwAYTCADABhMIAMAGEwgAwAYTCADABhMIAMAGEwgAwAYTCADABhMIAMAGOyM0QUssiuuOZxLrzyYI0eP5ewd27N/7+7sO2/X6LIAgNOMQLaGK645nIsvvy7H7jieJDl89Fguvvy6JBHKAIAtZchyDZdeefBTYeyEY3ccz6VXHhxUEQBwuhLI1nDk6LFTagcA2CyBbA1n79h+Su0AAJslkK1h/97d2X7mtru0bT9zW/bv3T2oIgDgdGVS/xpOTNx3lSUAMGsC2Tr2nbdLAAMAZs6QJQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGACGQDAYAIZAMBgAhkAwGAzC2RV9fKquqWqrl/V9uKqOlxV104/T1+17OKqurGqDlbV3lnVBQCwaGZ5huxXkzz1JO0/3d3nTj+/nSRV9UVJnp3kcVOfX6iqbTOsDQBgYcwskHX325LctsHVn5Hktd39ie7+QJIbk5w/q9oAABbJiDlkL6iq90xDmg+d2nYl+fCqdQ5NbQAAp715B7KXJfm8JOcmuSnJT03tdZJ1+2RfUFUXVtWBqjpw6623zqZKAIA5mmsg6+6bu/t4d38yyS/l74clDyV51KpVH5nkyBrfcVl37+nuPTt37pxtwQAAc3DGPDdWVY/o7pumj9+U5MQVmG9M8uqqemmSs5M8NslV86xtpCuuOZxLrzyYI0eP5ewd27N/7+7sO8+ILQAsi5kFsqp6TZILkpxVVYeS/EiSC6rq3KwMR34wyfOTpLtvqKrXJfmTJHcm+e7uPj6r2hbJFdcczsWXX5djd6z8uoePHsvFl1+XJEIZACyJ6j7pVK37hD179vSBAwdGl3GvPOmSt+bw0WP/oH3Xju15x0VPHlARADALVXV1d+852TJ36h/syEnC2HrtAMDpRyAb7Owd20+pHQA4/Qhkg+3fuzvbz7zrQwm2n7kt+/fuHlQRADBvc73Kkn/oxMR9V1kCwPISyBbAvvN2CWAAsMQMWQIADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADDazQFZVL6+qW6rq+lVtl1bVn1bVe6rqDVW1Y2o/p6qOVdW1089/nVVdAACLZpZnyH41yVPv1vbmJF/c3f84yZ8luXjVsvd197nTz3fNsC4AgIUys0DW3W9Lctvd2n63u++cPv5RkkfOavsAAPcVI+eQfWeSN636/Jiquqaq/qCqvmKtTlV1YVUdqKoDt9566+yrBACYsSGBrKr+ryR3JnnV1HRTkkd393lJXpjk1VX14JP17e7LuntPd+/ZuXPnfAoGAJihuQeyqnpukq9P8q+7u5Okuz/R3X89vb86yfuSfP68awMAGGGugayqnprkB5J8Y3d/fFX7zqraNr3/3CSPTfL+edYGADDKGbP64qp6TZILkpxVVYeS/EhWrqq8f5I3V1WS/NF0ReVXJvnRqrozyfEk39Xdt530iwEATjMzC2Td/ZyTNP/KGuu+PsnrZ1ULAMAic6d+AIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMFmFsiq6uVVdUtVXb+q7TOr6s1V9efT60NXLbu4qm6sqoNVtXdWdQEALJpZniH71SRPvVvbRUne0t2PTfKW6XOq6ouSPDvJ46Y+v1BV22ZYGwDAwphZIOvutyW57W7Nz0jyiun9K5LsW9X+2u7+RHd/IMmNSc6fVW0AAItk3nPIHt7dNyXJ9PqwqX1Xkg+vWu/Q1AYAcNpblEn9dZK2PumKVRdW1YGqOnDrrbfOuCwAgNmbdyC7uaoekSTT6y1T+6Ekj1q13iOTHDnZF3T3Zd29p7v37Ny5c6bFAgDMw7wD2RuTPHd6/9wkv7Gq/dlVdf+qekySxya5as61AQAMccasvriqXpPkgiRnVdWhJD+S5JIkr6uq5yX5iyTfnCTdfUNVvS7JnyS5M8l3d/fxWdUGALBIZhbIuvs5ayz66jXW//EkPz6regAAFtWiTOoHAFhaAhkAwGACGQDAYKcUyGrFA2ZVDADAMrrHQFZV/72qHlxVn5HkhiQfqKoXzr40AIDlsJEzZI/v7o9m5bmTv5uVm7Z++yyLAgBYJhsJZPerqjOy8gDwK7r775J8crZlAQAsj40Esl/Oyk1cH5rkD6rq0Ulun2lVAABL5B4DWXf/dHef3d1P6e5O8uEkT559aQAAy2Ejk/pfUFUPnt7/YpJ3JvmKWRcGALAsNjJkeWF3f7SqnpJkV5J/l+QnZlsWAMDy2Egg6+n1aUn+W3dfvcF+AABswEaC1R9X1W8n+YYkb6qqB+bvQxoAAPfSGRtY5zuSPDHJjd398ao6K8nzZlsWAMDyuMdA1t3HpxD2zKpKkj/o7jfNvDIAgCWxkassfzzJ9yd5//Szv6p+bNaFAQAsi40MWX5Dkid0951JUlUvT/LuJD84y8IAAJbFRq+WfNAa7wEAuJc2cobsJ5K8u6rekqSSXJDkh2dZFADAMtnIpP5XVtXvJfmnWQlkP9zdh2deGQDAklgzkFXVP75b043T62dV1Wd193tmV9Z91xXXHM6lVx7MkaPHcvaO7dm/d3f2nbdrdFkAwAJb7wzZz6+zrJN85RbXcp93xTWHc/Hl1+XYHceTJIePHsvFl1+XJEIZALCmNQNZd3uA+Cm69MqDnwpjJxy743guvfKgQAYArMkzKbfQkaPHTqkdACARyLbU2Tu2n1I7AEAikG2p/Xt3Z/uZ2+7Stv3Mbdm/d/egigCA+4J7vO3FSa62TJKPJPlwd39y60u67zoxT8xVlgDAqdjIjWF/Jcm5SW7Iyn3IvjDJ9UkeUlUXdvdbZljffc6+83YJYADAKdnIkOWfJ3lid5/b3V+S5IlJrk2yN8lPzbI4AIBlsJFA9oWrbwLb3ddl5WHjN67TBwCADdrIkOX7qurnkrx2+vysJDdW1f2T3DmzygAAlsRGzpB9W5JDSS5KcnGSI0mem5Uw9tWzKw0AYDls5OHiH0/y/0w/d/eRLa8IAGDJbOS2F1+a5EeSfM7q9bv782dYFwDA0tjIHLL/luT7k1yd5Pg9rAsAwCnaSCD7aHf/5swrAQBYUhsJZG+tqpckuTzJJ040rr4VBgAAm7eRQPbld3tNkk7ylVtfDgDA8tnIVZZfMY9CAACW1ZqBrKqe092vqar/cLLl3f1fZlcWAMDyWO8M2UOn153zKAQAYFmtGci6+xem1x+aXzkAAMtnIzeGPSvJdyY5J3e9MeyFsysLAGB5bOQqy99I8kdJ3h43hgUA2HIbCWQP6O7vm3klAABL6tM2sM6bquopM68EAGBJbSSQfVeS36mq26vqtqr6m6q6bdaFAQAsi40MWZ418yo4ZVdccziXXnkwR44ey9k7tmf/3t3Zd96u0WUBAJuw3o1hH9vdf57kcWus4lmWg1xxzeFcfPl1OXbHyjUWh48ey8WXX5ckQhkA3Aetd4bsoiTPS/LzJ1nmWZYDXXrlwU+FsROO3XE8l155UCADgPug9W4M+7zpdUufZVlVu5P82qqmz03yw0l2JPm3SW6d2l/U3b+9lds+XRw5euyU2gGAxbaROWSpqi9I8kVJPv1EW3e/ejMb7O6DSc6dvndbksNJ3pDkO5L8dHf/5Ga+d5mcvWN7Dp8kfJ29Y/uAagCAe+ser7Ksqh9MclmS/5rkaUl+Jsm/2KLtf3WS93X3h7bo+5bC/r27s/3MbXdp237mtuzfu3tQRQDAvbGR2148K8lXJbmpu781yZdkg2fWNuDZSV6z6vMLquo9VfXyqnroWp2W3b7zduUlz3x8du3Ynkqya8f2vOSZjzd/DADuo6q711+h6qruPr+qrk5yQZLbk1zX3V98rzZcdb8kR5I8rrtvrqqHJ/mrrFww8J+TPKK7v/Mk/S5McmGSPPrRj37ihz7k5BoAsPiq6uru3nOyZRs5Q3ZNVe1I8vIkB5JcleTdW1DX05K8u7tvTpLuvrm7j3f3J5P8UpLzT9apuy/r7j3dvWfnzp1bUAYAwFjrDj1WVSV5cXcfTfLzVXVlkgd391YEsudk1XBlVT2iu2+aPn5Tkuu3YBsAAAtv3UDW3V1Vv5XkidPnG7dio1X1GUm+NsnzVzX/RFWdm5Uhyw/ebRkAwGlrI5Pzr6qqJ2zRWbEkSXd/PMln3a3tW7fq+wEA7kvWe3TSGd19Z5IvT/Jvq+p9Sf42SWXl5NkT5lQjAMBpbb0zZFcleUKSfXOqBQBgKa0XyCpJuvt9c6oFAGAprRfIdlbVC9da2N0vnUE9AABLZ71Ati3JAzOdKQMAYDbWC2Q3dfePzq0SAIAltd6d+p0ZAwCYg/UC2VfPrQoAgCW2ZiDr7tvmWQgAwLLayMPFAQCYIYEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYDCBDABgMIEMAGAwgQwAYLAzRmy0qj6Y5GNJjie5s7v3VNVnJvm1JOck+WCSf9ndfzOiPgCAeRp5huyruvvc7t4zfb4oyVu6+7FJ3jJ9BgA47S3SkOUzkrxiev+KJPsG1gIAMDejAlkn+d2qurqqLpzaHt7dNyXJ9Pqwk3Wsqgur6kBVHbj11lvnVC4AwOwMmUOW5EndfaSqHpbkzVX1pxvt2N2XJbksSfbs2dOzKhAAYF6GnCHr7iPT6y1J3pDk/CQ3V9UjkmR6vWVEbQAA8zb3QFZVD6iqB514n+QpSa5P8sYkz51We26S35h3bQAAI4wYsnx4kjdU1Yntv7q7f6eq3pXkdVX1vCR/keSbB9QGADB3cw9k3f3+JF9ykva/TvLV864HAGC0RbrtBQDAUhLIAAAGE8gAAAYTyAAABhPIAAAGE8gAAAYTyAAABhPIAAAGE8gAAAYTyAAABhPIAAAGE8gAAAYTyAAABhPIAAAGE8gAAAYTyAAABhPIAAAGE8gAAAYTyAAABhPIAAAGE8gAAAY7Y3QBLLYrrjmcS688mCNHj+XsHduzf+/u7Dtv1+iyAOC0IpCxpiuuOZyLL78ux+44niQ5fPRYLr78uiQRygBgCxmyZE2XXnnwU2HshGN3HM+lVx4cVBEAnJ4EMtZ05OixU2oHADZHIGNNZ+/YfkrtAMDmCGSsaf/e3dl+5ra7tG0/c1v27909qCIAOD2Z1M+aTkzcd5UlAMyWQMa69p23SwADgBkzZAkAMJhABgAwmEAGADCYQAYAMJhJ/UvEcykBYDEJZEvCcykBYHEZslwSnksJAItLIFsSnksJAItLIFsSnksJAItLIFsSnksJAIvLpP4l4bmUALC4BLIl4rmUALCYDFkCAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMJpABAAwmkAEADCaQAQAMNvdAVlWPqqrfq6r3VtUNVfU9U/uLq+pwVV07/Tx93rUBAIww4tFJdyb5vu5+d1U9KMnVVfXmadlPd/dPDqgJAGCYuQey7r4pyU3T+49V1XuTeMAiALC0hs4hq6pzkpyX5J1T0wuq6j1V9fKqeuiwwgAA5mhYIKuqByZ5fZLv7e6PJnlZks9Lcm5WzqD91Br9LqyqA1V14NZbb51bvQAAszIkkFXVmVkJY6/q7suTpLtv7u7j3f3JJL+U5PyT9e3uy7p7T3fv2blz5/yKBgCYkRFXWVaSX0ny3u5+6ar2R6xa7ZuSXD/v2gAARhhxleWTknxrkuuq6tqp7UVJnlNV5ybpJB9M8vwBtQEAzN2IqyzfnqROsui3510LAMAicKd+AIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwQQyAIDBBDIAgMEEMgCAwc4YXQCnnyuuOZxLrzyYI0eP5ewd27N/7+7sO2/X6LIAYGEJZGypK645nIsvvy7H7jieJDl89Fguvvy6JBHKAGANhizZUpdeefBTYeyEY3ccz6VXHhxUEQAsPoGMLXXk6LFTagcABDK22Nk7tp9SOwAgkLHF9u/dne1nbrtL2/Yzt2X/3t2DKgKAxWdSP1vqxMR9V1kCwMYJZGy5feftEsAA4BQYsgQAGEwgAwAYTCADABhMIAMAGMykfrgHns0JwKwJZLCORX82p7AIcHowZAnrWORnc54Ii4ePHkvn78PiFdccHl0aAKdIIIN1LPKzORc5LAJwagQyWMciP5tzkcMiAKdGIIN1LPKzORc5LAJwagQyWMe+83blJc98fHbt2J5KsmvH9rzkmY9fiInzixwWATg1rrJkqWzmqsRFfTanB7kDnD4EMpbGot/CYjMWNSwCcGoMWbI0XJUIwKJyhoylsehXJbrJK8DyEshYCPMII2fv2J7DJwlfi3BV4uk4nArAxhmyZLjN3nH+imsO50mXvDWPueh/5kmXvPUe11/kqxINpwIsN4GM4TYTRjYT4hb5FhaLPpwKwGwZsmS4zYSR9ULcegFrUa9KXOThVFaY4wfMkkDGcJsJI4t+RulU/+O9f+/uu8whSxZnOHWeFjX0mOMHzJohS4bbzNyuRX5s0Ok2nDovm51LuNltncr8w83O8TvV7QDLa+HOkFXVU5P8bJJtSX65uy8ZXBIztpk7zi/yGaVFH07dzFmoefTZ7H47VZs527WZM7LzPKs2r78pMDsLFciqaluSn0/ytUkOJXlXVb2xu/9kbGXM2qmGkUV+bNAiD6duJiTMq89m99s8gt9mhtU3GzBP9feZ199nM7Xpo8/p2mcWFiqQJTk/yY3d/f4kqarXJnlGEoGMf8AE/VO3mZAwrz6b2W/zCn6bOSM7r7Nq8/r7LHKY10efefaZlUWbQ7YryYdXfT40tcF9xiLf72wzIWFefTaz3zYzt2sz8w83M8dvM9vZzO8zr7/PZmrTR5/Tsc+sLNoZsjpJW99lhaoLk1yYJI9+9KPnUROckkUeTt3MWah59dnMfpvX2a4T9Z3K33BeZ9Xm9fdZ5DCvjz7z7DMri3aG7FCSR636/MgkR1av0N2Xdfee7t6zc+fOuRYHG7XvvF15x0VPzgcu+bq846InL0QYSzZ3FmpefZJT32/zOtu1GfM6qzavv89matNHn9Oxz6wsWiB7V5LHVtVjqup+SZ6d5I2Da4LTxmZCwrz6bMa8gt9mnep2NvP7zOvvs8hhXh995tlnVqq773mtOaqqpyf5mazc9uLl3f3ja627Z8+ePnDgwNxqAxbPolwhtVUW+fdZ5Kve9NFnnn02q6qu7u49J122aIHsVAhkAMB9xXqBbNGGLAEAlo5ABgAwmEAGADCYQAYAMJhABgAwmEAGADCYQAYAMJhABgAwmEAGADCYQAYAMJhABgAwmEAGADCYQAYAMJhABgAwmEAGADBYdffoGjatqm5N8qE5bOqsJH81h+0sMvvAPkjsg8Q+SOyDxD5I7IPk1PfB53T3zpMtuE8HsnmpqgPdvWd0HSPZB/ZBYh8k9kFiHyT2QWIfJFu7DwxZAgAMJpABAAwmkG3MZaMLWAD2gX2Q2AeJfZDYB4l9kNgHyRbuA3PIAAAGc4YMAGAwgWwdVfXUqjpYVTdW1UWj6xmhqj5YVddV1bVVdWB0PfNSVS+vqluq6vpVbZ9ZVW+uqj+fXh86ssZZW2MfvLiqDk/Hw7VV9fSRNc5SVT2qqn6vqt5bVTdU1fdM7UtzHKyzD5bpOPj0qrqqqv542gf/aWpfpuNgrX2wNMfBCVW1raquqarfmj5v2XFgyHINVbUtyZ8l+dokh5K8K8lzuvtPhhY2Z1X1wSR7unup7jVTVV+Z5PYk/727v3hq+4kkt3X3JVNAf2h3/8DIOmdpjX3w4iS3d/dPjqxtHqrqEUke0d3vrqoHJbk6yb4k354lOQ7W2Qf/MstzHFSSB3T37VV1ZpK3J/meJM/M8hwHa+2Dp2ZJjoMTquqFSfYkeXB3f/1W/nfBGbK1nZ/kxu5+f3f/XZLXJnnG4JqYk+5+W5Lb7tb8jCSvmN6/IoAVJZIAAATLSURBVCv/YTptrbEPlkZ339Td757efyzJe5PsyhIdB+vsg6XRK26fPp45/XSW6zhYax8slap6ZJKvS/LLq5q37DgQyNa2K8mHV30+lCX7h2jSSX63qq6uqgtHFzPYw7v7pmTlP1RJHja4nlFeUFXvmYY0T9thmtWq6pwk5yV5Z5b0OLjbPkiW6DiYhqmuTXJLkjd399IdB2vsg2SJjoMkP5Pk+5N8clXblh0HAtna6iRtS/d/BEme1N1PSPK0JN89DWOxvF6W5POSnJvkpiQ/Nbac2auqByZ5fZLv7e6Pjq5nhJPsg6U6Drr7eHefm+SRSc6vqi8eXdO8rbEPluY4qKqvT3JLd189q20IZGs7lORRqz4/MsmRQbUM091HptdbkrwhK0O5y+rmaU7Nibk1twyuZ+66++bpH+ZPJvmlnObHwzRf5vVJXtXdl0/NS3UcnGwfLNtxcEJ3H03y+1mZO7VUx8EJq/fBkh0HT0ryjdO86tcmeXJVvTJbeBwIZGt7V5LHVtVjqup+SZ6d5I2Da5qrqnrANJE3VfWAJE9Jcv36vU5rb0zy3On9c5P8xsBahjjxD8/km3IaHw/TROZfSfLe7n7pqkVLcxystQ+W7DjYWVU7pvfbk3xNkj/Nch0HJ90Hy3QcdPfF3f3I7j4nK3ngrd39LdnC4+CMe13laaq776yqFyS5Msm2JC/v7hsGlzVvD0/yhpV/k3NGkld39++MLWk+quo1SS5IclZVHUryI0kuSfK6qnpekr9I8s3jKpy9NfbBBVV1blaG7z+Y5PnDCpy9JyX51iTXTXNnkuRFWa7jYK198JwlOg4ekeQV05X3n5bkdd39W1X1h1me42CtffA/lug4WMuW/XvgthcAAIMZsgQAGEwgAwAYTCADABhMIAMAGEwgAwAYTCAD7vOq6vbp9Zyq+ldb/N0vutvn/3crvx8gEciA08s5SU4pkE33VlrPXQJZd/8fp1gTwD0SyIDTySVJvqKqrq2q/zg9EPnSqnrX9ADk5ydJVV1QVb9XVa9Oct3UdkVVXV1VN1TVhVPbJUm2T9/3qqntxNm4mr77+qq6rqqeteq7f7+qfr2q/rSqXjXd8R5gTe7UD5xOLkryf3b31yfJFKw+0t3/pKrun+QdVfW707rnJ/ni7v7A9Pk7u/u26dEw76qq13f3RVX1gumhynf3zKw8VPlLkpw19XnbtOy8JI/LyvNv35GVO96/fet/XeB04QwZcDp7SpJvmx77884kn5XksdOyq1aFsST5D1X1x0n+KMmjVq23li9P8prp4co3J/mDJP9k1Xcfmh66fG1WhlIB1uQMGXA6qyT/vruvvEtj1QVJ/vZun78myZd198er6veTfPoGvnstn1j1/nj8WwvcA2fIgNPJx5I8aNXnK5P8u6o6M0mq6vOr6gEn6feQJH8zhbEvSPKlq5bdcaL/3bwtybOmeWo7k3xlkqu25LcAlo7/awNOJ+9Jcuc09PirSX42K8OF754m1t+aZN9J+v1Oku+qqvckOZiVYcsTLkvynqp6d3f/61Xtb0jyZUn+OEkn+f7u/ssp0AGckuru0TUAACw1Q5YAAIMJZAAAgwlkAACDCWQAAIMJZAAAgwlkAACDCWQAAIMJZAAAg/3/0gkKs1GzhXsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 5e-4  # Experiment with this!\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.559978\n",
      "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.107000\n",
      "(Iteration 11 / 200) loss: 2.356069\n",
      "(Iteration 21 / 200) loss: 2.214091\n",
      "(Iteration 31 / 200) loss: 2.205928\n",
      "(Epoch 1 / 5) train acc: 0.225000; val_acc: 0.193000\n",
      "(Iteration 41 / 200) loss: 2.132095\n",
      "(Iteration 51 / 200) loss: 2.118950\n",
      "(Iteration 61 / 200) loss: 2.116443\n",
      "(Iteration 71 / 200) loss: 2.132549\n",
      "(Epoch 2 / 5) train acc: 0.298000; val_acc: 0.260000\n",
      "(Iteration 81 / 200) loss: 1.977227\n",
      "(Iteration 91 / 200) loss: 2.007528\n",
      "(Iteration 101 / 200) loss: 2.004762\n",
      "(Iteration 111 / 200) loss: 1.885342\n",
      "(Epoch 3 / 5) train acc: 0.343000; val_acc: 0.287000\n",
      "(Iteration 121 / 200) loss: 1.891516\n",
      "(Iteration 131 / 200) loss: 1.923677\n",
      "(Iteration 141 / 200) loss: 1.957744\n",
      "(Iteration 151 / 200) loss: 1.966736\n",
      "(Epoch 4 / 5) train acc: 0.322000; val_acc: 0.305000\n",
      "(Iteration 161 / 200) loss: 1.801483\n",
      "(Iteration 171 / 200) loss: 1.973780\n",
      "(Iteration 181 / 200) loss: 1.666573\n",
      "(Iteration 191 / 200) loss: 1.909494\n",
      "(Epoch 5 / 5) train acc: 0.372000; val_acc: 0.319000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.153777\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.088000\n",
      "(Iteration 11 / 200) loss: 2.227203\n",
      "(Iteration 21 / 200) loss: 2.125706\n",
      "(Iteration 31 / 200) loss: 1.932695\n",
      "(Epoch 1 / 5) train acc: 0.307000; val_acc: 0.260000\n",
      "(Iteration 41 / 200) loss: 1.946488\n",
      "(Iteration 51 / 200) loss: 1.778583\n",
      "(Iteration 61 / 200) loss: 1.758119\n",
      "(Iteration 71 / 200) loss: 1.849137\n",
      "(Epoch 2 / 5) train acc: 0.382000; val_acc: 0.322000\n",
      "(Iteration 81 / 200) loss: 2.048671\n",
      "(Iteration 91 / 200) loss: 1.693223\n",
      "(Iteration 101 / 200) loss: 1.511693\n",
      "(Iteration 111 / 200) loss: 1.390754\n",
      "(Epoch 3 / 5) train acc: 0.458000; val_acc: 0.338000\n",
      "(Iteration 121 / 200) loss: 1.670614\n",
      "(Iteration 131 / 200) loss: 1.540272\n",
      "(Iteration 141 / 200) loss: 1.597365\n",
      "(Iteration 151 / 200) loss: 1.609851\n",
      "(Epoch 4 / 5) train acc: 0.490000; val_acc: 0.327000\n",
      "(Iteration 161 / 200) loss: 1.472687\n",
      "(Iteration 171 / 200) loss: 1.378620\n",
      "(Iteration 181 / 200) loss: 1.378175\n",
      "(Iteration 191 / 200) loss: 1.306440\n",
      "(Epoch 5 / 5) train acc: 0.529000; val_acc: 0.369000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:39: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:42: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:39: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:42: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:49: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.476928\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.027712\n",
      "(Iteration 21 / 200) loss: 2.183358\n",
      "(Iteration 31 / 200) loss: 1.744257\n",
      "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
      "(Iteration 41 / 200) loss: 1.707951\n",
      "(Iteration 51 / 200) loss: 1.703835\n",
      "(Iteration 61 / 200) loss: 2.094758\n",
      "(Iteration 71 / 200) loss: 1.505558\n",
      "(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.362000\n",
      "(Iteration 81 / 200) loss: 1.594429\n",
      "(Iteration 91 / 200) loss: 1.519017\n",
      "(Iteration 101 / 200) loss: 1.368522\n",
      "(Iteration 111 / 200) loss: 1.470400\n",
      "(Epoch 3 / 5) train acc: 0.460000; val_acc: 0.378000\n",
      "(Iteration 121 / 200) loss: 1.199064\n",
      "(Iteration 131 / 200) loss: 1.464705\n",
      "(Iteration 141 / 200) loss: 1.359863\n",
      "(Iteration 151 / 200) loss: 1.415069\n",
      "(Epoch 4 / 5) train acc: 0.521000; val_acc: 0.374000\n",
      "(Iteration 161 / 200) loss: 1.382818\n",
      "(Iteration 171 / 200) loss: 1.359900\n",
      "(Iteration 181 / 200) loss: 1.095947\n",
      "(Iteration 191 / 200) loss: 1.243088\n",
      "(Epoch 5 / 5) train acc: 0.572000; val_acc: 0.382000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.589166\n",
      "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
      "(Iteration 11 / 200) loss: 2.032921\n",
      "(Iteration 21 / 200) loss: 1.897278\n",
      "(Iteration 31 / 200) loss: 1.770793\n",
      "(Epoch 1 / 5) train acc: 0.381000; val_acc: 0.320000\n",
      "(Iteration 41 / 200) loss: 1.895731\n",
      "(Iteration 51 / 200) loss: 1.681091\n",
      "(Iteration 61 / 200) loss: 1.486923\n",
      "(Iteration 71 / 200) loss: 1.628511\n",
      "(Epoch 2 / 5) train acc: 0.423000; val_acc: 0.341000\n",
      "(Iteration 81 / 200) loss: 1.506182\n",
      "(Iteration 91 / 200) loss: 1.600674\n",
      "(Iteration 101 / 200) loss: 1.478501\n",
      "(Iteration 111 / 200) loss: 1.577709\n",
      "(Epoch 3 / 5) train acc: 0.487000; val_acc: 0.355000\n",
      "(Iteration 121 / 200) loss: 1.495931\n",
      "(Iteration 131 / 200) loss: 1.525799\n",
      "(Iteration 141 / 200) loss: 1.552580\n",
      "(Iteration 151 / 200) loss: 1.654283\n",
      "(Epoch 4 / 5) train acc: 0.524000; val_acc: 0.362000\n",
      "(Iteration 161 / 200) loss: 1.589371\n",
      "(Iteration 171 / 200) loss: 1.413528\n",
      "(Iteration 181 / 200) loss: 1.500273\n",
      "(Iteration 191 / 200) loss: 1.365943\n",
      "(Epoch 5 / 5) train acc: 0.532000; val_acc: 0.374000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "C:\\Users\\zhijiezheng\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:40: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 620) loss: 46.448708\n",
      "(Epoch 0 / 10) train acc: 0.149000; val_acc: 0.120000\n",
      "(Iteration 11 / 620) loss: 41.835496\n",
      "(Iteration 21 / 620) loss: 40.121783\n",
      "(Iteration 31 / 620) loss: 38.517347\n",
      "(Iteration 41 / 620) loss: 37.407260\n",
      "(Iteration 51 / 620) loss: 36.483636\n",
      "(Iteration 61 / 620) loss: 35.591336\n",
      "(Epoch 1 / 10) train acc: 0.401000; val_acc: 0.279000\n",
      "(Iteration 71 / 620) loss: 34.629439\n",
      "(Iteration 81 / 620) loss: 33.952560\n",
      "(Iteration 91 / 620) loss: 32.888066\n",
      "(Iteration 101 / 620) loss: 32.366211\n",
      "(Iteration 111 / 620) loss: 31.479661\n",
      "(Iteration 121 / 620) loss: 30.818888\n",
      "(Epoch 2 / 10) train acc: 0.422000; val_acc: 0.330000\n",
      "(Iteration 131 / 620) loss: 30.511378\n",
      "(Iteration 141 / 620) loss: 29.741173\n",
      "(Iteration 151 / 620) loss: 29.227815\n",
      "(Iteration 161 / 620) loss: 28.630244\n",
      "(Iteration 171 / 620) loss: 27.986683\n",
      "(Iteration 181 / 620) loss: 27.253518\n",
      "(Epoch 3 / 10) train acc: 0.469000; val_acc: 0.338000\n",
      "(Iteration 191 / 620) loss: 26.641727\n",
      "(Iteration 201 / 620) loss: 26.384157\n",
      "(Iteration 211 / 620) loss: 25.710730\n",
      "(Iteration 221 / 620) loss: 25.219221\n",
      "(Iteration 231 / 620) loss: 24.917030\n",
      "(Iteration 241 / 620) loss: 24.280826\n",
      "(Epoch 4 / 10) train acc: 0.513000; val_acc: 0.343000\n",
      "(Iteration 251 / 620) loss: 23.653584\n",
      "(Iteration 261 / 620) loss: 23.571498\n",
      "(Iteration 271 / 620) loss: 22.928487\n",
      "(Iteration 281 / 620) loss: 22.718699\n",
      "(Iteration 291 / 620) loss: 22.256951\n",
      "(Iteration 301 / 620) loss: 21.836180\n",
      "(Epoch 5 / 10) train acc: 0.533000; val_acc: 0.359000\n",
      "(Iteration 311 / 620) loss: 21.230491\n",
      "(Iteration 321 / 620) loss: 20.865416\n",
      "(Iteration 331 / 620) loss: 20.247412\n",
      "(Iteration 341 / 620) loss: 20.270852\n",
      "(Iteration 351 / 620) loss: 20.068091\n",
      "(Iteration 361 / 620) loss: 19.624373\n",
      "(Iteration 371 / 620) loss: 19.080009\n",
      "(Epoch 6 / 10) train acc: 0.564000; val_acc: 0.358000\n",
      "(Iteration 381 / 620) loss: 18.847557\n",
      "(Iteration 391 / 620) loss: 18.515211\n",
      "(Iteration 401 / 620) loss: 17.993084\n",
      "(Iteration 411 / 620) loss: 17.854795\n",
      "(Iteration 421 / 620) loss: 17.478858\n",
      "(Iteration 431 / 620) loss: 17.159718\n",
      "(Epoch 7 / 10) train acc: 0.578000; val_acc: 0.368000\n",
      "(Iteration 441 / 620) loss: 16.886613\n",
      "(Iteration 451 / 620) loss: 16.636194\n",
      "(Iteration 461 / 620) loss: 16.307896\n",
      "(Iteration 471 / 620) loss: 15.881656\n",
      "(Iteration 481 / 620) loss: 15.788971\n",
      "(Iteration 491 / 620) loss: 15.490212\n",
      "(Epoch 8 / 10) train acc: 0.577000; val_acc: 0.374000\n",
      "(Iteration 501 / 620) loss: 15.265341\n",
      "(Iteration 511 / 620) loss: 15.042647\n",
      "(Iteration 521 / 620) loss: 14.477381\n",
      "(Iteration 531 / 620) loss: 14.345641\n",
      "(Iteration 541 / 620) loss: 14.127653\n",
      "(Iteration 551 / 620) loss: 13.859100\n",
      "(Epoch 9 / 10) train acc: 0.626000; val_acc: 0.377000\n",
      "(Iteration 561 / 620) loss: 13.575125\n",
      "(Iteration 571 / 620) loss: 13.279693\n",
      "(Iteration 581 / 620) loss: 13.104684\n",
      "(Iteration 591 / 620) loss: 12.831661\n",
      "(Iteration 601 / 620) loss: 12.560148\n",
      "(Iteration 611 / 620) loss: 12.493125\n",
      "(Epoch 10 / 10) train acc: 0.594000; val_acc: 0.368000\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "model = FullyConnectedNet([100, 100, 100, 100], dropout=1, normalization=None, weight_scale=5e-2, reg = 1e-1)\n",
    "learning_rate = 1e-4\n",
    "solver = Solver(model, small_data,\n",
    "              num_epochs=10, batch_size=64,\n",
    "              update_rule=update_rule,\n",
    "              optim_config={\n",
    "                'learning_rate': learning_rate\n",
    "              },\n",
    "              verbose=True)\n",
    "solvers['adam'] = solver\n",
    "solver.train()\n",
    "best_model = model\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.377\n",
      "Test set accuracy:  0.375\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
